import {
  getNewCartGoods,
  reqMergeLocalCart,
  reqFindCartList,
  reqInsertCart,
  reqDeleteCart,
  reqUpdateCartSku,
  reqCheckAllCart,
} from "@/api/cart";
export default {
  state() {
    return {
      list: [],
    };
  },
  mutations: {
    insertCart(state, goods) {
      // 需要判断添加的商品在不在购物车中===在不在list中
      var index = state.list.findIndex((item) => item.skuId === goods.skuId);
      if (index >= 0) {
        //表示添加的商品在购物车中有===数量叠加
        state.list[index].count += goods.count;
      } else {
        // 表示购物车中没有这件商品
        state.list.unshift(goods);
      }
    },
    delCart(state, goods) {
      //  [1,2,3,4,5]  =1
      // state.list = state.list.filter((item) => item.skuId !== goods.skuId);
      var index = state.list.findIndex((item) => item.skuId === goods.skuId);
      state.list.splice(index, 1);
    },
    updateCart(state, goods) {
      // state.list=res
      console.log(goods, 777);
      //  根据skuId从list中找==找到对应项
      var skuObj = state.list.find((item) => item.skuId === goods.skuId);
      skuObj.isEffective = goods.isEffective;
      skuObj.nowPrice = goods.nowPrice;
      skuObj.stock = goods.stock;

      console.log(skuObj, 99222);
    },
    /* 更改状态 */
    checkCart(state, { selected, goods }) {
      const checkObj = state.list.find((item) => item.skuId == goods.skuId);
      checkObj.selected = selected;
    },
    /* 更改数量 */
    countCart(state, { count, goods }) {
      const checkObj = state.list.find((item) => item.skuId == goods.skuId);
      checkObj.count = count;
    },
    setList(state, newList) {
      state.list = newList;
    },
    isAll(state, selected) {
      state.list.forEach((item) => {
        item.selected = selected;
      });
    },
  },
  actions: {
    asyncInsertCart(context, goods) {
      console.log(context, 9887);
      return new Promise(async (resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // 登录的
          const { skuId, count } = goods;
          await reqInsertCart({ skuId, count });
          //获取最新的购物车中的商品===刷新购物车中的商品
          context.dispatch("asyncUpdateCart");
          resolve();
        } else {
          // 没有登录的
          context.commit("insertCart", goods);
          resolve();
        }
      });
    },
    asyncDelCart(context, goods) {
      // 删除商品
      return new Promise(async (resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // 登录的
          // var ids = goods.map((item) => item.skuId); //可以实现批量删除 要求是一个数组
          // var ids = goods.map((item) => item.skuId); //可以实现批量删除 要求是一个数组
          await reqDeleteCart([goods.skuId]);
          //获取最新的购物车中的商品===刷新购物车中的商品
          context.dispatch("asyncUpdateCart");
        } else {
          // 没有登录的
          context.commit("delCart", goods);
          resolve();
        }
      });
    },
    asyncUpdateCart(context) {
      return new Promise(async (resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // 登录的
          /* 获取的是用户登录之后的购物车中的商品====类似于state/list */
          const res = await reqFindCartList();
          console.log(res, 88776);
          context.commit("setList", res.result);
        } else {
          // 没有登录的
          console.log(context, 44);
          //  获取skuId  然后获取最新的数据===来更新数据列表
          var requestArr = context.state.list.map((item) => {
            return getNewCartGoods(item.skuId);
          });
          Promise.all(requestArr).then((res) => {
            console.log(res, 5564);
            res.forEach((item, index) => {
              context.commit("updateCart", {
                ...item.result,
                skuId: context.state.list[index].skuId,
              });
            });
          });
          resolve();
        }
      });
    },
    asyncCheckCart(context, { selected, goods }) {
      return new Promise(async (resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // 登录的
          var newGoods = {
            skuId: goods.skuId,
            selected,
          };
          await reqUpdateCartSku(newGoods);
          //获取最新的购物车中的商品===刷新购物车中的商品
          context.dispatch("asyncUpdateCart");
        } else {
          // 没有登录的
          context.commit("checkCart", { selected, goods });
          resolve();
        }
      });
    },
    /* 更新数量 */
    asyncCountCart(context, { count, goods }) {
      return new Promise(async (resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // 登录的
          var newGoods = {
            skuId: goods.skuId,
            count: goods.count,
          };
          await reqUpdateCartSku(newGoods);
          //获取最新的购物车中的商品===刷新购物车中的商品
          context.dispatch("asyncUpdateCart");
        } else {
          // 没有登录的
          context.commit("countCart", { count, goods });
          resolve();
        }
      });
    },
    /* 合并购物车 */
    /* 合并购物车 */
    async asyncMergeList(context) {
      // var cartList = context.state.list.map((item) => {
      //   return {
      //     skuId: item.skuId,
      //     selected: item.selected,
      //     count: item.count,
      //   };
      // });
      var cartList = context.state.list.map(({ skuId, selected, count }) => {
        return {
          skuId,
          selected,
          count,
        };
      });
      await reqMergeLocalCart(cartList);
    },

    /* 全选和反选 */
    asyncIsAll(context, selected) {
      return new Promise(async (resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // console.log(context, 777);
          var ids = context.getters.effectiveList.map((item) => item.skuId);
          await reqCheckAllCart({ selected, ids });
          // //获取最新的购物车中的商品===刷新购物车中的商品
          context.dispatch("asyncUpdateCart");
        } else {
          // 没有登录的
          context.commit("isAll", selected);
          resolve();
        }
      });
    },

    // asyncUserCart()
  },
  getters: {
    // 获取有效商品====判断商品是否是有效以及是否有库存
    effectiveList(state) {
      return state.list.filter((item) => item.isEffective && item.stock > 0);
    },
    //获取有效的数叠加
    // console.log(getters.effectiveList, 995522);
    effectiveTotal(state, getters) {
      return getters.effectiveList.reduce(
        (count, item) => count + item.count,
        0
      );
    },
    /* 有效商品总价钱 */
    effectivePrice(state, getters) {
      return getters.effectiveList
        .reduce((sum, item) => sum + item.count * item.nowPrice, 0)
        .toFixed(2);
    },
    /* 无效的商品 */
    inEffectiveList(state) {
      return state.list.filter((item) => !(item.isEffective && item.stock > 0));
    },
    /* 获取有效的并选中的 */
    effectiveSelectedList(state, getters) {
      return getters.effectiveList.filter((item) => item.selected);
    },
    /* 获取选中的数量 */
    effectiveSelectedCount(state, getters) {
      return getters.effectiveSelectedList.reduce(
        (count, item) => count + item.count,
        0
      );
    },
    selectedEffectivePrice(state, getters) {
      return getters.effectiveSelectedList
        .reduce((sum, item) => sum + item.count * item.nowPrice, 0)
        .toFixed(2);
    },
    selectedALL(state, getters) {
      return getters.effectiveList.every((item) => item.selected);
    },
  },
  namespaced: true,
};
